ജാവസ്ക്രിപ്റ്റ് ടെംപോറൽ ഡ്യൂറേഷൻ അരിത്മെറ്റിക്: ടൈം ഇന്റർവെൽ മാത്തമാറ്റിക്സിനെക്കുറിച്ചുള്ള ഒരു ആഗോള ഗൈഡ്

വെബ് ഡെവലപ്‌മെന്റിന്റെ എപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുന്ന ലോകത്ത്, സമയം കൃത്യമായും വിശ്വസനീയമായും കൈകാര്യം ചെയ്യേണ്ടത് അത്യാവശ്യമാണ്. നിങ്ങൾ വ്യത്യസ്ത ടൈം സോണുകളിലുടനീളമുള്ള പ്രോജക്റ്റ് ഡെഡ്‌ലൈനുകൾ കണക്കാക്കുകയാണെങ്കിലും, സബ്‌സ്‌ക്രിപ്‌ഷൻ പുതുക്കലുകൾ നിയന്ത്രിക്കുകയാണെങ്കിലും, അല്ലെങ്കിൽ ആഗോളതലത്തിൽ ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്യുകയാണെങ്കിലും, കൃത്യമായ ടൈം ഇന്റർവെൽ മാത്തമാറ്റിക്സ് അത്യാവശ്യമാണ്. ആധുനിക ജാവസ്ക്രിപ്റ്റ് ഇതിനായി ഒരു ശക്തമായ ഉപകരണം അവതരിപ്പിച്ചു: ടെംപോറൽ എപിഐ (Temporal API), പ്രത്യേകിച്ചും അതിന്റെ ഡ്യൂറേഷൻ (Duration) ഒബ്ജക്റ്റ്. ഈ സമഗ്രമായ ഗൈഡ് ജാവസ്ക്രിപ്റ്റ് ടെംപോറൽ ഡ്യൂറേഷൻ അരിത്മെറ്റിക്കിനെക്കുറിച്ചുള്ള സംശയങ്ങൾ ദൂരീകരിക്കുകയും, അതിന്റെ കഴിവുകളെയും പ്രായോഗിക പ്രയോഗങ്ങളെയും കുറിച്ച് ഒരു ആഗോള കാഴ്ചപ്പാട് നൽകുകയും ചെയ്യും.

സമയം കൈകാര്യം ചെയ്യുന്നതിൽ ശക്തമായ ഒരു സംവിധാനത്തിന്റെ ആവശ്യകത

ചരിത്രപരമായി, ജാവസ്ക്രിപ്റ്റിന്റെ ബിൽറ്റ്-ഇൻ Date ഒബ്ജക്റ്റ് ഡെവലപ്പർമാർക്ക് ഒരുപാട് ബുദ്ധിമുട്ടുകൾ ഉണ്ടാക്കിയിട്ടുണ്ട്. അതിന്റെ പൊരുത്തക്കേടുകൾ, മാറ്റാൻ കഴിയാത്ത സ്വഭാവമില്ലായ്മ (lack of immutability), ടൈം സോണുകളും ഡേലൈറ്റ് സേവിംഗ് ടൈമും കൈകാര്യം ചെയ്യുന്നതിലെ സങ്കീർണ്ണത എന്നിവ നിരവധി ബഗുകൾക്കും ബാഹ്യ ലൈബ്രറികളുടെ നിരന്തരമായ ആവശ്യകതയ്ക്കും കാരണമായി. ടെംപോറൽ എപിഐ, ECMAScript-നുള്ള ഒരു നിർദ്ദിഷ്ട സ്റ്റാൻഡേർഡ്, തീയതികളും സമയങ്ങളും കാലയളവുകളും കൈകാര്യം ചെയ്യാൻ കൂടുതൽ ലളിതവും സ്ഥിരതയുള്ളതും ശക്തവുമായ ഒരു മാർഗ്ഗം നൽകിക്കൊണ്ട് ഈ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ലക്ഷ്യമിടുന്നു.

ആഗോളതലത്തിൽ പ്രവർത്തിക്കുമ്പോൾ, ഈ വെല്ലുവിളികൾ വർദ്ധിക്കുന്നു. ഉദാഹരണത്തിന്:

• ബെർലിനിലുള്ള ഒരു പ്രോജക്റ്റ് മാനേജർ, ടോക്കിയോയിലേക്കുള്ള ഒരു ഷിപ്പ്‌മെന്റിന്റെ ഡെലിവറി സമയം കണക്കാക്കുന്നു, ടൈം സോൺ വ്യത്യാസങ്ങളും സാധ്യമായ കാലതാമസങ്ങളും കണക്കിലെടുക്കുന്നു.
• യൂറോപ്പിലെ വിവിധ സാമ്പത്തിക പാദങ്ങളിൽ നൽകിയ രണ്ട് പലിശ പേയ്‌മെന്റുകൾക്കിടയിലുള്ള കൃത്യമായ കാലയളവ് ന്യൂയോർക്കിലെ ഒരു സാമ്പത്തിക അനലിസ്റ്റ് നിർണ്ണയിക്കുന്നു.
• സിംഗപ്പൂരിലെ ഒരു മാർക്കറ്റിംഗ് ടീം ഒരു ആഗോള കാമ്പെയ്‌ൻ ലോഞ്ച് ഷെഡ്യൂൾ ചെയ്യുന്നു, അത് വടക്കേ അമേരിക്ക, യൂറോപ്പ്, ഏഷ്യ എന്നിവിടങ്ങളിലെ പ്രധാന കാഴ്ചാ സമയങ്ങളുമായി യോജിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

ഈ സാഹചര്യങ്ങൾ ടൈം ഇന്റർവെൽ മാത്തമാറ്റിക്സിന് ഒരു സ്റ്റാൻഡേർഡ്, വ്യക്തമായ സമീപനത്തിന്റെ നിർണായക ആവശ്യകത എടുത്തു കാണിക്കുന്നു. ടെംപോറൽ എപിഐയുടെ Duration ഒബ്ജക്റ്റ് ഈ ആവശ്യം നേരിട്ട് നിറവേറ്റാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്.

ജാവസ്ക്രിപ്റ്റ് ടെംപോറൽ ഡ്യൂറേഷൻ ഒബ്ജക്റ്റിനെ പരിചയപ്പെടാം

Temporal.Duration ഒബ്ജക്റ്റ് ഒരു പ്രത്യേക സമയത്തെ ആശ്രയിക്കാതെ, ഒരു സമയത്തിന്റെ അളവിനെ പ്രതിനിധീകരിക്കുന്നു. ഇത് '2 വർഷം, 3 മാസം, 4 ദിവസം' പോലുള്ള കഴിഞ്ഞുപോയ സമയത്തിന്റെ ഒരു അളവാണ്. മുമ്പത്തെ സമീപനങ്ങളിൽ നിന്ന് വ്യത്യസ്തമായി, Temporal.Duration സമയത്തിന്റെ അളവിൽ മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. ഈ വേർതിരിവാണ് അതിന്റെ ശക്തിക്കും ലാളിത്യത്തിനും കാരണം.

ഒരു ഡ്യൂറേഷന്റെ പ്രധാന ഘടകങ്ങൾ

ഒരു Temporal.Duration ഒബ്ജക്റ്റിന് വിവിധ യൂണിറ്റുകളിൽ സമയം പ്രതിനിധീകരിക്കാൻ കഴിയും. ഇത് പിന്തുണയ്ക്കുന്ന പ്രധാന യൂണിറ്റുകൾ ഇവയാണ്:

• വർഷങ്ങൾ (years)
• മാസങ്ങൾ (months)
• ആഴ്ചകൾ (weeks)
• ദിവസങ്ങൾ (days)
• മണിക്കൂറുകൾ (hours)
• മിനിറ്റുകൾ (minutes)
• സെക്കൻഡുകൾ (seconds)
• മില്ലിസെക്കൻഡുകൾ (milliseconds)
• മൈക്രോസെക്കൻഡുകൾ (microseconds)
• നാനോസെക്കൻഡുകൾ (nanoseconds)

ഒരു Duration ഒബ്ജക്റ്റ് പോസിറ്റീവ് (മുന്നോട്ടുള്ള സമയത്തെ പ്രതിനിധീകരിക്കുന്നു) അല്ലെങ്കിൽ നെഗറ്റീവ് (പിന്നോട്ടുള്ള സമയത്തെ പ്രതിനിധീകരിക്കുന്നു) ആകാം. Temporal.Duration മാറ്റാൻ കഴിയാത്തതാണ് (immutable) എന്നത് ശ്രദ്ധിക്കേണ്ടത് പ്രധാനമാണ്. ഒരിക്കൽ സൃഷ്ടിച്ചാൽ, അതിന്റെ മൂല്യം മാറ്റാൻ കഴിയില്ല. ഒരു ഡ്യൂറേഷനെ മാറ്റുന്നതായി തോന്നുന്ന ഏത് പ്രവർത്തനവും യഥാർത്ഥത്തിൽ ഒരു പുതിയ Duration ഒബ്ജക്റ്റ് നൽകുന്നു.

ടെംപോറൽ ഡ്യൂറേഷനുകൾ സൃഷ്ടിക്കുന്നു

നിങ്ങൾക്ക് പല രീതികളിൽ Temporal.Duration ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കാൻ കഴിയും, ഓരോന്നും വ്യത്യസ്ത സാഹചര്യങ്ങൾക്ക് അനുയോജ്യമാണ്.

1. Temporal.Duration.from() മെത്തേഡ് ഉപയോഗിച്ച്

ഇതാണ് ഏറ്റവും വൈവിധ്യമാർന്ന രീതി, ഇത് ഒരു ഒബ്ജക്റ്റ് ലിറ്ററൽ അല്ലെങ്കിൽ ഒരു ISO 8601 ഡ്യൂറേഷൻ സ്ട്രിംഗ് ഉൾപ്പെടെ വിവിധ ഇൻപുട്ടുകളിൽ നിന്ന് ഒരു ഡ്യൂറേഷൻ നിർമ്മിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഒരു ഒബ്ജക്റ്റ് ലിറ്ററലിൽ നിന്ന്:

നിങ്ങൾ ഉൾപ്പെടുത്താൻ ആഗ്രഹിക്കുന്ന യൂണിറ്റുകൾ ഒരു ഒബ്ജക്റ്റിന്റെ പ്രോപ്പർട്ടികളായി നൽകുക.

            const twoYearsThreeMonths = Temporal.Duration.from({
  years: 2,
  months: 3
});

console.log(twoYearsThreeMonths);
// Temporal.Duration { years: 2, months: 3, ... }

const oneDayEightHours = Temporal.Duration.from({
  days: 1,
  hours: 8,
  minutes: 30
});

console.log(oneDayEightHours);
// Temporal.Duration { days: 1, hours: 8, minutes: 30, ... }

const negativeDuration = Temporal.Duration.from({
  hours: -5,
  minutes: -15
});

console.log(negativeDuration);
// Temporal.Duration { hours: -5, minutes: -15, ... }

            

              
                Copy
              
            
          

ഒരു ISO 8601 ഡ്യൂറേഷൻ സ്ട്രിംഗിൽ നിന്ന്:

ISO 8601 സ്റ്റാൻഡേർഡ് ഡ്യൂറേഷനുകൾക്കായി ഒരു ചെറിയ സ്ട്രിംഗ് റെപ്രസെന്റേഷൻ നൽകുന്നു. ഫോർമാറ്റ് PnYnMnDTnHnMnS ആണ്, ഇവിടെ:

• P ഡ്യൂറേഷന്റെ തുടക്കത്തെ സൂചിപ്പിക്കുന്നു.
• Y വർഷങ്ങളെ പ്രതിനിധീകരിക്കുന്നു.
• M മാസങ്ങളെ പ്രതിനിധീകരിക്കുന്നു.
• D ദിവസങ്ങളെ പ്രതിനിധീകരിക്കുന്നു.
• T തീയതി ഘടകങ്ങളെ സമയ ഘടകങ്ങളിൽ നിന്ന് വേർതിരിക്കുന്നു.
• H മണിക്കൂറുകളെ പ്രതിനിധീകരിക്കുന്നു.
• M മിനിറ്റുകളെ പ്രതിനിധീകരിക്കുന്നു.
• S സെക്കൻഡുകളെ പ്രതിനിധീകരിക്കുന്നു.

'T' ന് ശേഷമുള്ള 'M' മിനിറ്റുകളെയും 'T' ന് മുമ്പുള്ള 'M' മാസങ്ങളെയും സൂചിപ്പിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. സമയ യൂണിറ്റുകൾ (മണിക്കൂർ, മിനിറ്റ്, സെക്കൻഡ്) ഓപ്ഷണലാണ്, പൂജ്യമല്ലാത്ത മൂല്യമുണ്ടെങ്കിൽ മാത്രമേ ദൃശ്യമാകൂ.

            const isoDuration1 = Temporal.Duration.from('P1Y2M3DT4H5M6S');
console.log(isoDuration1);
// Temporal.Duration { years: 1, months: 2, days: 3, hours: 4, minutes: 5, seconds: 6, ... }

const isoDuration2 = Temporal.Duration.from('P10DT5H'); // 10 days, 5 hours
console.log(isoDuration2);
// Temporal.Duration { days: 10, hours: 5, ... }

const isoDuration3 = Temporal.Duration.from('P3M'); // 3 months
console.log(isoDuration3);
// Temporal.Duration { months: 3, ... }

// Invalid ISO 8601 strings will throw an error.
// Temporal.Duration.from('PT10M5S'); // This is valid
// Temporal.Duration.from('10M'); // This is not valid without 'P'

            

              
                Copy
              
            
          

2. Temporal.Duration() കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ച്

കൺസ്ട്രക്റ്റർ നേരിട്ടുള്ള ഇൻസ്റ്റൻഷിയേഷൻ അനുവദിക്കുന്നു, പക്ഷേ സാധാരണയായി from() ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു, കാരണം ഇത് കൂടുതൽ വഴക്കവും തെറ്റായ ഇൻപുട്ടുകൾക്ക് മികച്ച എറർ ഹാൻഡ്‌ലിംഗും നൽകുന്നു.

            const constructorDuration = new Temporal.Duration(0, 0, 0, 1, 2, 3); // years, months, weeks, days, hours, minutes
console.log(constructorDuration);
// Temporal.Duration { years: 0, months: 0, weeks: 0, days: 1, hours: 2, minutes: 3, ... }

// Note: The constructor takes arguments in a fixed order (years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds).
// Providing fewer arguments means later units are treated as zero.
const partialDuration = new Temporal.Duration(1, 6); // 1 year, 6 months
console.log(partialDuration);
// Temporal.Duration { years: 1, months: 6, ... }

            

              
                Copy
              
            
          

ഡ്യൂറേഷൻ ഘടകങ്ങൾ ആക്‌സസ് ചെയ്യൽ

നിങ്ങൾക്ക് ഒരു Temporal.Duration ഒബ്ജക്റ്റ് ലഭിച്ചുകഴിഞ്ഞാൽ, പ്രോപ്പർട്ടികൾ ഉപയോഗിച്ച് അതിന്റെ ഓരോ ഘടകങ്ങളെയും ആക്‌സസ് ചെയ്യാൻ കഴിയും:

            const myDuration = Temporal.Duration.from({
  years: 5,
  days: 10,
  hours: 12,
  minutes: 45
});

console.log(myDuration.years);
// 5
console.log(myDuration.days);
// 10
console.log(myDuration.hours);
// 12
console.log(myDuration.minutes);
// 45
console.log(myDuration.seconds); // Units not specified are 0
// 0

            

              
                Copy
              
            
          

ടെംപോറൽ ഡ്യൂറേഷൻ അരിത്മെറ്റിക്: പ്രധാന പ്രവർത്തനങ്ങൾ

Temporal.Duration ഒബ്ജക്റ്റിന്റെ യഥാർത്ഥ ശക്തി അതിന്റെ അരിത്മെറ്റിക് പ്രവർത്തനങ്ങളിലാണ്. ഈ പ്രവർത്തനങ്ങൾ നിങ്ങൾക്ക് ഡ്യൂറേഷനുകൾ കൂട്ടാനും കുറയ്ക്കാനും ഗുണിക്കാനും ഹരിക്കാനും അനുവദിക്കുന്നു, ഇത് സമയ ഇടവേളകളിൽ കൃത്യമായ നിയന്ത്രണം നൽകുന്നു.

1. ഡ്യൂറേഷനുകൾ കൂട്ടിച്ചേർക്കൽ (add())

add() മെത്തേഡ് രണ്ട് Temporal.Duration ഒബ്ജക്റ്റുകളെ സംയോജിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഡ്യൂറേഷനുകൾ കൂട്ടുമ്പോൾ, യൂണിറ്റുകൾ ഒന്നിച്ചു ചേർക്കപ്പെടുന്നു. ഉദാഹരണത്തിന്, '1 വർഷം', '2 മാസം' എന്നിവ ചേർത്താൽ '1 വർഷം, 2 മാസം' എന്ന ഡ്യൂറേഷൻ ലഭിക്കും.

            const duration1 = Temporal.Duration.from({ days: 10, hours: 5 });
const duration2 = Temporal.Duration.from({ days: 5, hours: 10 });

const totalDuration = duration1.add(duration2);
console.log(totalDuration);
// Temporal.Duration { days: 15, hours: 15, ... }

const duration3 = Temporal.Duration.from({ years: 1, months: 6 });
const duration4 = Temporal.Duration.from({ months: 8, days: 15 });

const combinedDuration = duration3.add(duration4);
console.log(combinedDuration);
// Temporal.Duration { years: 1, months: 14, days: 15, ... }
// Note: This is a simple aggregation. Temporal will handle unit rollovers (e.g., 14 months becoming 1 year and 2 months) when interacting with PlainDate/Time objects.

// Adding a negative duration is equivalent to subtraction
const duration5 = Temporal.Duration.from({ hours: 3 });
const duration6 = Temporal.Duration.from({ hours: -1 });

const result = duration5.add(duration6);
console.log(result);
// Temporal.Duration { hours: 2, ... }

            

              
                Copy
              
            
          

2. ഡ്യൂറേഷനുകൾ കുറയ്ക്കൽ (subtract())

subtract() മെത്തേഡ് add()-ന് സമാനമായി പ്രവർത്തിക്കുന്നു, പക്ഷേ കുറയ്ക്കൽ പ്രവർത്തനം നടത്തുന്നു.

            const durationA = Temporal.Duration.from({ days: 20, hours: 10 });
const durationB = Temporal.Duration.from({ days: 5, hours: 3 });

const remainingDuration = durationA.subtract(durationB);
console.log(remainingDuration);
// Temporal.Duration { days: 15, hours: 7, ... }

// Subtracting a duration that results in a negative value
const durationC = Temporal.Duration.from({ minutes: 30 });
const durationD = Temporal.Duration.from({ minutes: 45 });

const negativeResult = durationC.subtract(durationD);
console.log(negativeResult);
// Temporal.Duration { minutes: -15, ... }

            

              
                Copy
              
            
          

3. ഒരു ഡ്യൂറേഷനെ നെഗറ്റീവ് ആക്കൽ (negated())

negated() മെത്തേഡ് അതിന്റെ എല്ലാ ഘടകങ്ങളും വിപരീതമാക്കിയ ഒരു പുതിയ Duration ഒബ്ജക്റ്റ് നൽകുന്നു (പോസിറ്റീവ് നെഗറ്റീവ് ആകുന്നു, നെഗറ്റീവ് പോസിറ്റീവ് ആകുന്നു).

            const positiveDuration = Temporal.Duration.from({ hours: 10, minutes: 30 });
const negativeDuration = positiveDuration.negated();
console.log(negativeDuration);
// Temporal.Duration { hours: -10, minutes: -30, ... }

const alreadyNegative = Temporal.Duration.from({ days: -5 });
const nowPositive = alreadyNegative.negated();
console.log(nowPositive);
// Temporal.Duration { days: 5, ... }

            

              
                Copy
              
            
          

4. ഒരു ഡ്യൂറേഷന്റെ കേവലമൂല്യം (abs())

abs() മെത്തേഡ് അതിന്റെ എല്ലാ ഘടകങ്ങളും നെഗറ്റീവ് അല്ലാത്തതാക്കിയ ഒരു പുതിയ Duration ഒബ്ജക്റ്റ് നൽകുന്നു. സമയ ഇടവേളയുടെ ദിശ പരിഗണിക്കാതെ, അതിന്റെ അളവ് മാത്രം അറിയേണ്ടി വരുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

            const negativeDuration = Temporal.Duration.from({ hours: -8, minutes: -20 });
const absoluteDuration = negativeDuration.abs();
console.log(absoluteDuration);
// Temporal.Duration { hours: 8, minutes: 20, ... }

            

              
                Copy
              
            
          

5. ഡ്യൂറേഷനുകൾ ഗുണിക്കൽ (multiply())

multiply() മെത്തേഡ് ഒരു ഡ്യൂറേഷനെ ഒരു നിശ്ചിത സംഖ്യ കൊണ്ട് ഗുണിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ആവർത്തിച്ചുള്ള ഇവന്റുകളുടെ മൊത്തം സമയം കണക്കാക്കുകയോ അല്ലെങ്കിൽ ഒരു അടിസ്ഥാന ഇടവേളയെ അടിസ്ഥാനമാക്കി ഭാവിയിലെ നാഴികക്കല്ലുകൾ നിർണ്ണയിക്കുകയോ പോലുള്ള ജോലികൾക്ക് ഇത് വളരെ ഉപയോഗപ്രദമാണ്.

            const dailyDuration = Temporal.Duration.from({ days: 1 });
const twoWeeks = dailyDuration.multiply(14);
console.log(twoWeeks);
// Temporal.Duration { days: 14, ... }

const hourlyIncrement = Temporal.Duration.from({ hours: 1 });
const workWeek = hourlyIncrement.multiply(40);
console.log(workWeek);
// Temporal.Duration { hours: 40, ... }

const projectPhase = Temporal.Duration.from({ months: 2 });
const fullProject = projectPhase.multiply(3);
console.log(fullProject);
// Temporal.Duration { months: 6, ... }

// Multiplication can also be done with negative numbers
const futureEvent = Temporal.Duration.from({ days: 5 }).multiply(-2);
console.log(futureEvent);
// Temporal.Duration { days: -10, ... }

            

              
                Copy
              
            
          

6. ഡ്യൂറേഷനുകൾ ഹരിക്കൽ (divide())

divide() മെത്തേഡ് ഒരു ഡ്യൂറേഷനെ ഒരു നിശ്ചിത സംഖ്യ കൊണ്ട് ഹരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു ഇവന്റിന്റെ ശരാശരി ദൈർഘ്യം നിർണ്ണയിക്കുകയോ അല്ലെങ്കിൽ ഒരു മൊത്തം സമയത്തെ ചെറിയ, തുല്യ ഭാഗങ്ങളായി വിഭജിക്കുകയോ പോലുള്ള ജോലികൾക്ക് ഇത് ഉപയോഗപ്രദമാണ്.

ഹരണത്തെക്കുറിച്ചുള്ള പ്രധാന കുറിപ്പ്: ടെംപോറൽ Duration-ലെ ഹരണം ഓരോ ഘടകത്തിനും ഒരു പൂർണ്ണസംഖ്യ യൂണിറ്റ് നൽകാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. ഭിന്നസംഖ്യ ഭാഗങ്ങൾ സാധാരണയായി ഒഴിവാക്കപ്പെടുന്നു (floored). ഭിന്നസംഖ്യ ഫലങ്ങൾ ആവശ്യമുള്ള സാഹചര്യങ്ങളിൽ, നിങ്ങൾ സാധാരണയായി PlainDateTime അല്ലെങ്കിൽ Instant ഒബ്ജക്റ്റുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുകയും തുടർന്ന് ഫലമായുണ്ടാകുന്ന ഡ്യൂറേഷൻ കണക്കാക്കുകയും ചെയ്യും.

            const totalWorkTime = Temporal.Duration.from({ hours: 40, minutes: 30 });
const timePerTask = totalWorkTime.divide(5);
console.log(timePerTask);
// Temporal.Duration { hours: 8, minutes: 1, ... } // 40.5 hours / 5 = 8.1 hours. The 0.1 hours (6 minutes) is truncated.

const projectDuration = Temporal.Duration.from({ days: 90 });
const phaseDuration = projectDuration.divide(3);
console.log(phaseDuration);
// Temporal.Duration { days: 30, ... }

// Dividing by a negative number
const longDuration = Temporal.Duration.from({ years: 2 }).divide(-4);
console.log(longDuration);
// Temporal.Duration { years: -0, ... } // -0.5 years results in 0 years due to truncation.
// For more precise calculations involving division and fractional parts, consider using methods that operate on Temporal.Instant or Temporal.PlainDateTime.

            

              
                Copy
              
            
          

7. ഡ്യൂറേഷനുകൾ റൗണ്ട് ചെയ്യൽ (round())

round() മെത്തേഡ് ഡ്യൂറേഷനുകൾ സാധാരണ നിലയിലാക്കാൻ നിർണായകമാണ്, പ്രത്യേകിച്ചും വ്യത്യസ്ത യൂണിറ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോഴോ അല്ലെങ്കിൽ ഒരു നിശ്ചിത കൃത്യതയോടെ ഒരു ഡ്യൂറേഷൻ ഒരു പ്രത്യേക യൂണിറ്റിൽ പ്രകടിപ്പിക്കേണ്ടിവരുമ്പോഴോ. ഇത് ഒരു യൂണിറ്റും ഒരു റൗണ്ടിംഗ് മോഡും ആർഗ്യുമെന്റുകളായി എടുക്കുന്നു.

സാധാരണ റൗണ്ടിംഗ് മോഡുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

• Temporal.RoundingMode.trunc: പൂജ്യത്തിലേക്ക് വെട്ടിച്ചുരുക്കുന്നു.
• Temporal.RoundingMode.floor: താഴേക്ക് റൗണ്ട് ചെയ്യുന്നു.
• Temporal.RoundingMode.ceil: മുകളിലേക്ക് റൗണ്ട് ചെയ്യുന്നു.
• Temporal.RoundingMode.halfExpand: പോസിറ്റീവ് അനന്തതയിലേക്ക് റൗണ്ട് ചെയ്യുന്നു, പകുതികൾ പൂജ്യത്തിൽ നിന്ന് അകലെ റൗണ്ട് ചെയ്യുന്നു.

            const impreciseDuration = Temporal.Duration.from({
  hours: 2,
  minutes: 35,
  seconds: 45
});

// Round to the nearest minute, using halfExpand (standard rounding)
const roundedToMinute = impreciseDuration.round('minute', Temporal.RoundingMode.halfExpand);
console.log(roundedToMinute);
// Temporal.Duration { hours: 2, minutes: 36, ... } // 35 minutes and 45 seconds rounds up to 36 minutes

// Truncate to the nearest hour
const truncatedToHour = impreciseDuration.round('hour', Temporal.RoundingMode.trunc);
console.log(truncatedToHour);
// Temporal.Duration { hours: 2, ... } // Discards the minutes and seconds.

// Round up to the nearest hour
const ceiledToHour = impreciseDuration.round('hour', Temporal.RoundingMode.ceil);
console.log(ceiledToHour);
// Temporal.Duration { hours: 3, ... } // Since there are minutes and seconds, it rounds up.

// Rounding to a smaller unit (e.g., to seconds) can reveal more precision
const preciseRounding = impreciseDuration.round('second', Temporal.RoundingMode.halfExpand);
console.log(preciseRounding);
// Temporal.Duration { hours: 2, minutes: 35, seconds: 45, ... }

            

              
                Copy
              
            
          

8. ഡ്യൂറേഷനുകൾ താരതമ്യം ചെയ്യൽ (compare())

സ്റ്റാറ്റിക് Temporal.Duration.compare() മെത്തേഡ് രണ്ട് Duration ഒബ്ജക്റ്റുകളെ താരതമ്യം ചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഇത് നൽകുന്നത്:

• 1 ആദ്യത്തെ ഡ്യൂറേഷൻ രണ്ടാമത്തേതിനേക്കാൾ വലുതാണെങ്കിൽ.
• -1 ആദ്യത്തെ ഡ്യൂറേഷൻ രണ്ടാമത്തേതിനേക്കാൾ ചെറുതാണെങ്കിൽ.
• 0 ഡ്യൂറേഷനുകൾ തുല്യമാണെങ്കിൽ.

താരതമ്യം ചെയ്യുന്നത് രണ്ട് ഡ്യൂറേഷനുകളെയും ഒരു പൊതുവായ ഏറ്റവും ചെറിയ യൂണിറ്റിലേക്ക് (നാനോസെക്കൻഡ്) പരിവർത്തനം ചെയ്ത് അവയുടെ സംഖ്യാ മൂല്യങ്ങൾ താരതമ്യം ചെയ്തുകൊണ്ടാണ്. ഇത് യഥാർത്ഥ ഡ്യൂറേഷൻ ഒബ്ജക്റ്റുകളിൽ ഉപയോഗിച്ച യൂണിറ്റുകൾ പരിഗണിക്കാതെ തന്നെ കൃത്യമായ താരതമ്യം ഉറപ്പാക്കുന്നു.

            const durationX = Temporal.Duration.from({ days: 1, hours: 12 }); // 1.5 days
const durationY = Temporal.Duration.from({ hours: 36 });     // 1.5 days
const durationZ = Temporal.Duration.from({ days: 2 });       // 2 days

console.log(Temporal.Duration.compare(durationX, durationY)); // 0 (equal)
console.log(Temporal.Duration.compare(durationX, durationZ)); // -1 (durationX is less than durationZ)
console.log(Temporal.Duration.compare(durationZ, durationY)); // 1 (durationZ is greater than durationY)

// Comparison with negative durations
const negDuration1 = Temporal.Duration.from({ hours: -5 });
const negDuration2 = Temporal.Duration.from({ hours: -10 });

console.log(Temporal.Duration.compare(negDuration1, negDuration2)); // 1 (e.g., -5 is greater than -10)

            

              
                Copy
              
            
          

ഡ്യൂറേഷനുകളും തീയതികളും/സമയങ്ങളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു

Temporal.Duration ഒരു സമയത്തിന്റെ അളവിനെ പ്രതിനിധീകരിക്കുമ്പോൾ, അതിന്റെ യഥാർത്ഥ ഉപയോഗം പലപ്പോഴും Temporal.PlainDate, Temporal.PlainDateTime, Temporal.ZonedDateTime, Temporal.Instant പോലുള്ള പ്രത്യേക സമയ പോയിന്റുകളുമായോ തീയതി/സമയ ഒബ്ജക്റ്റുകളുമായോ സംയോജിപ്പിക്കുമ്പോഴാണ് തിരിച്ചറിയുന്നത്. ഈ ഒബ്ജക്റ്റുകളിലെ ഗണിത പ്രവർത്തനങ്ങൾ പരോക്ഷമായി ഡ്യൂറേഷൻ കണക്കുകൂട്ടലുകൾ ഉപയോഗിക്കും.

തീയതികളിൽ/സമയങ്ങളിൽ നിന്ന് ഡ്യൂറേഷനുകൾ കൂട്ടിച്ചേർക്കുക/കുറയ്ക്കുക

തീയതി/സമയ ഒബ്ജക്റ്റുകളിലെ add(), subtract() പോലുള്ള മെത്തേഡുകൾ ഒരു Duration ആർഗ്യുമെന്റായി എടുക്കുന്നു. അധിവർഷങ്ങൾ, വ്യത്യസ്ത ദിവസങ്ങളുള്ള മാസങ്ങൾ തുടങ്ങിയ കലണ്ടർ ഗണിതത്തിന്റെ സങ്കീർണ്ണതകൾ ടെംപോറൽ കൈകാര്യം ചെയ്യുന്നത് ഇവിടെയാണ്.

            // Example using Temporal.PlainDate (requires polyfill or native support)
// Assuming you have a Temporal polyfill or native support in your environment.

// Let's imagine today is July 15, 2024
const today = Temporal.PlainDate.from({ year: 2024, month: 7, day: 15 });

const durationToAdd = Temporal.Duration.from({ years: 1, months: 3, days: 15 });

const futureDate = today.add(durationToAdd);
console.log(futureDate);
// Temporal.PlainDate { year: 2025, month: 11, day: 1 }

// Global example: Calculating a future date considering different month lengths
const londonDate = Temporal.PlainDate.from({ year: 2024, month: 1, day: 31 }); // January 31st
const durationForNextMonth = Temporal.Duration.from({ months: 1 });

const nextMonthDate = londonDate.add(durationForNextMonth);
console.log(nextMonthDate);
// Temporal.PlainDate { year: 2024, month: 2, day: 29 } // Correctly handles leap year and end of month.

const newYorkDate = Temporal.ZonedDateTime.from({
  timeZone: 'America/New_York',
  year: 2024,
  month: 10,
  day: 28,
  hour: 10,
  minute: 0,
  second: 0
});

const travelDuration = Temporal.Duration.from({ hours: 8 }); // An 8-hour flight

// Note: When adding durations to ZonedDateTime, it's crucial to consider the time zone.
// The result will be in the same time zone unless specified otherwise.
const arrivalTimeNY = newYorkDate.add(travelDuration);
console.log(arrivalTimeNY);
// Temporal.ZonedDateTime { year: 2024, month: 10, day: 28, hour: 18, minute: 0, second: 0, ... }

// If you want to calculate arrival time in a DIFFERENT time zone, you'd typically:
// 1. Add duration to the departure ZonedDateTime.
// 2. Convert the resulting ZonedDateTime to the destination time zone.
const tokyoTimeZone = 'Asia/Tokyo';
const arrivalTimeTokyo = arrivalTimeNY.withTimeZone(tokyoTimeZone);
console.log(arrivalTimeTokyo);
// Temporal.ZonedDateTime { year: 2024, month: 10, day: 29, hour: 7, minute: 0, second: 0, ... } (Note the date and time change due to time zone)

            

              
                Copy
              
            
          

തീയതികൾ/സമയങ്ങൾക്കിടയിലുള്ള ഡ്യൂറേഷൻ കണക്കാക്കൽ

തീയതി/സമയ ഒബ്ജക്റ്റുകളിലെ until(), since() മെത്തേഡുകൾ ഒരു Temporal.Duration നൽകുന്നു. രണ്ട് പോയിന്റുകൾക്കിടയിൽ കഴിഞ്ഞുപോയ സമയം അളക്കുന്നത് ഇങ്ങനെയാണ്.

            const startDate = Temporal.PlainDate.from({ year: 2023, month: 1, day: 1 });
const endDate = Temporal.PlainDate.from({ year: 2024, month: 3, day: 15 });

const elapsedDuration = startDate.until(endDate);
console.log(elapsedDuration);
// Temporal.Duration { years: 1, months: 2, days: 14, ... }

// Global example: Calculating contract length difference
const contractStart = Temporal.ZonedDateTime.from({
  timeZone: 'UTC',
  year: 2022,
  month: 5,
  day: 10,
  hour: 9,
  minute: 0
});

const contractEnd = Temporal.ZonedDateTime.from({
  timeZone: 'UTC',
  year: 2025,
  month: 8,
  day: 20,
  hour: 17,
  minute: 30
});

const contractLength = contractStart.until(contractEnd);
console.log(contractLength);
// Temporal.Duration { years: 3, months: 3, days: 10, hours: 8, minutes: 30, ... }

// When using until/since with ZonedDateTime, the result can be complex due to time zones and DST.
// Temporal handles this by giving you a duration that may not 'round trip' perfectly if you just add it back without considering the time zone.

            

              
                Copy
              
            
          

മികച്ച രീതികളും ആഗോള പരിഗണനകളും

ടെംപോറൽ ഡ്യൂറേഷനുകളുമായി പ്രവർത്തിക്കുമ്പോൾ, പ്രത്യേകിച്ചും ആഗോള പശ്ചാത്തലത്തിൽ, ഈ കാര്യങ്ങൾ മനസ്സിൽ വെക്കുക:

• മാറ്റാനാവാത്ത സ്വഭാവം പ്രധാനം: എപ്പോഴും Duration ഒബ്ജക്റ്റുകളെ മാറ്റാനാവാത്തതായി കണക്കാക്കുക. ഏത് പ്രവർത്തനവും ഒരു പുതിയ ഒബ്ജക്റ്റ് നൽകുന്നു, ഇത് അപ്രതീക്ഷിത പാർശ്വഫലങ്ങൾ തടയുന്നു.
• യൂണിറ്റ് അഗ്രഗേഷനും കലണ്ടർ അരിത്മെറ്റിക്കും തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കുക: Duration അരിത്മെറ്റിക് സ്വയം യൂണിറ്റുകളുടെ ലളിതമായ സംയോജനം നടത്തുന്നു. നിങ്ങൾ ഒരു Duration-നെ ഒരു തീയതി/സമയ ഒബ്ജക്റ്റുമായി സംയോജിപ്പിക്കുമ്പോൾ, ടെംപോറലിന്റെ മെത്തേഡുകൾ (PlainDate-ലെ add() പോലുള്ളവ) കലണ്ടർ-അധിഷ്ഠിത ഗണിതം നടത്തുന്നു, ഇത് കൂടുതൽ സങ്കീർണ്ണവും മാസങ്ങളുടെ ദൈർഘ്യം, അധിവർഷങ്ങൾ തുടങ്ങിയവ കണക്കിലെടുക്കുന്നതുമാണ്.
• ടൈം സോണുകൾ വളരെ പ്രധാനമാണ്: വിവിധ പ്രദേശങ്ങളിലെ ഉപയോക്താക്കളുമായോ ഇവന്റുകളുമായോ ബന്ധപ്പെട്ട ഏതൊരു ആപ്ലിക്കേഷനും Temporal.ZonedDateTime ഉപയോഗിക്കുന്നത് അത്യാവശ്യമാണ്. Duration ഒബ്ജക്റ്റ് ടൈം-സോൺ-അജ്ഞാതമാണ്, എന്നാൽ ZonedDateTime-മായി അതിന്റെ പ്രയോഗം വിവിധ സോണുകളിലുടനീളമുള്ള സമയം ശരിയായി പ്രതിനിധീകരിക്കുന്നതിന് ശ്രദ്ധാപൂർവ്വം കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്.
• ISO 8601 നിങ്ങളുടെ സുഹൃത്താണ്: സാധ്യമാകുമ്പോഴെല്ലാം ഡ്യൂറേഷനുകൾക്കായി ISO 8601 സ്ട്രിംഗുകൾ ഉപയോഗിക്കുക. അവ സ്റ്റാൻഡേർഡ്, വ്യക്തവും, പാഴ്സ് ചെയ്യാനും നിർമ്മിക്കാനും എളുപ്പവുമാണ്, ഇത് സിസ്റ്റങ്ങൾക്കിടയിലുള്ള ഡാറ്റാ കൈമാറ്റത്തിനും അന്താരാഷ്ട്ര സ്ഥിരതയ്ക്കും അനുയോജ്യമാക്കുന്നു.
• അനുയോജ്യമായ റൗണ്ടിംഗ് തിരഞ്ഞെടുക്കുക: round() മെത്തേഡ് ശക്തമാണ്, പക്ഷേ നിങ്ങളുടെ റൗണ്ടിംഗ് ആവശ്യകതകളെക്കുറിച്ച് ധാരണ ആവശ്യമാണ്. സാമ്പത്തിക കണക്കുകൂട്ടലുകൾക്ക്, പ്രത്യേക റൗണ്ടിംഗ് നിയമങ്ങൾ ബാധകമായേക്കാം. പൊതുവായ സമയ പ്രദർശനത്തിന്, halfExpand സാധാരണയായി അനുയോജ്യമാണ്.
• ഉപയോക്തൃ അനുഭവം പരിഗണിക്കുക: ഉപയോക്താക്കൾക്ക് ഡ്യൂറേഷനുകൾ പ്രദർശിപ്പിക്കുമ്പോൾ, ഔട്ട്പുട്ട് പ്രാദേശികവൽക്കരിക്കുന്നത് പരിഗണിക്കുക. ടെംപോറൽ യഥാർത്ഥ ഡ്യൂറേഷൻ നൽകുമ്പോൾ, 'P1Y2M'-നെ '1 വർഷവും 2 മാസവും' അല്ലെങ്കിൽ '14 മാസം' എന്ന് അവതരിപ്പിക്കുന്നത് സന്ദർഭവും ലൊക്കേലും അനുസരിച്ച് കൂടുതൽ ഉപയോക്തൃ-സൗഹൃദമായേക്കാം.
• സ്റ്റാൻഡേർഡ് സ്വീകരിക്കുക: ടെംപോറൽ എപിഐ ഒരു സ്റ്റാൻഡേർഡ് ആയി മാറാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. ഇത് കൂടുതൽ വ്യാപകമായ അംഗീകാരവും ബ്രൗസർ പിന്തുണയും നേടുന്നതിനനുസരിച്ച്, ഇതിനെ ആശ്രയിക്കുന്നത് നിങ്ങളുടെ കോഡ് ലളിതമാക്കുകയും കൂടുതൽ പരിപാലിക്കാവുന്നതും ഭാവിയിൽ സുരക്ഷിതവുമാക്കുകയും ചെയ്യും.

ഉപസംഹാരം

ജാവസ്ക്രിപ്റ്റിന്റെ ടെംപോറൽ എപിഐ, അതിന്റെ Duration ഒബ്ജക്റ്റിനൊപ്പം, സമയം അടിസ്ഥാനമാക്കിയുള്ള കണക്കുകൂട്ടലുകൾ കൈകാര്യം ചെയ്യുന്നതിൽ ഒരു സുപ്രധാന കുതിച്ചുചാട്ടത്തെ പ്രതിനിധീകരിക്കുന്നു. ഡ്യൂറേഷൻ അരിത്മെറ്റിക്കിനായി ശക്തവും, മാറ്റാനാവാത്തതും, ഗണിതശാസ്ത്രപരമായി ശരിയായതുമായ ഒരു ചട്ടക്കൂട് നൽകുന്നതിലൂടെ, ഇത് ഡെവലപ്പർമാരെ കൂടുതൽ വിശ്വസനീയവും കൃത്യവുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ പ്രാപ്തരാക്കുന്നു. നിങ്ങൾ അന്താരാഷ്ട്ര പ്രോജക്റ്റുകൾ നിയന്ത്രിക്കുകയാണെങ്കിലും, ആഗോള ഷെഡ്യൂളിംഗ് ടൂളുകൾ വികസിപ്പിക്കുകയാണെങ്കിലും, അല്ലെങ്കിൽ കൃത്യമായ സമയ ഇടവേള കണക്കുകൂട്ടലുകൾ ആവശ്യമാണെങ്കിലും, ടെംപോറൽ ഡ്യൂറേഷൻ അരിത്മെറ്റിക്കിൽ വൈദഗ്ദ്ധ്യം നേടുന്നത് ഏതൊരു ആധുനിക ജാവസ്ക്രിപ്റ്റ് ഡെവലപ്പർക്കും അമൂല്യമായ ഒരു കഴിവായിരിക്കും.

ലോകം കൂടുതൽ പരസ്പരം ബന്ധിപ്പിക്കപ്പെടുമ്പോൾ, വിവിധ പ്രദേശങ്ങളിലും സന്ദർഭങ്ങളിലും സമയ ഇടവേളകൾ കൃത്യമായും അവബോധപരമായും കൈകാര്യം ചെയ്യാനുള്ള കഴിവ് ഒരു ആഡംബരമല്ല, മറിച്ച് ഒരു ആവശ്യകതയായി മാറിയിരിക്കുന്നു. Temporal.Duration ഒബ്ജക്റ്റ് ഈ കഴിവ് അൺലോക്ക് ചെയ്യുന്നതിനുള്ള നിങ്ങളുടെ താക്കോലാണ്, ഇത് കൂടുതൽ സങ്കീർണ്ണവും ആഗോളതലത്തിൽ അവബോധമുള്ളതുമായ ആപ്ലിക്കേഷനുകൾക്ക് വഴിയൊരുക്കുന്നു.